<?php

namespace app\models\tableModel;

use app\entity\PageListEntity;
use app\models\tableModel\base\NewsCategory;
use app\service\tool\ConvertService;
use app\service\tool\FileService;
use app\service\tool\UtilsService;
use yii\db\Expression;
use yii\db\ExpressionInterface;
use yii\helpers\ArrayHelper;

/**
 * [文章分类]数据库操作模型
 * 作者: Editor Name
 * 日期: 2022/01/15
 * 时间: 10:52:44
 */
class NewsCategoryModel extends NewsCategory
{

    /**
     * 状态 列表
     * @var array
     */
    private static $statusList = [
        [
            'key'   => 'open',
            'value' => 1,
            'text'  => '开启'
        ],
        [
            'key'   => 'disabled',
            'value' => -1,
            'text'  => '禁用'
        ],
    ];

    /**
     * 是否展示 列表
     * @var array
     */
    private static $isShowList = [
        [
            'key'   => 'show',
            'value' => 1,
            'text'  => '展示'
        ],
        [
            'key'   => 'hide',
            'value' => -1,
            'text'  => '隐藏'
        ],
    ];

    /**
     * 开启SEO 列表
     * @var array
     */
    private static $openSeoList = [
        [
            'key'   => 'close',
            'value' => -1,
            'text'  => '关闭'
        ],
        [
            'key'   => 'open',
            'value' => 1,
            'text'  => '开启'
        ]
    ];

    /**
     * 链接类型 列表
     * @var array
     */
    private static $urlTypeList = [
        [
            'key'   => 'site',
            'value' => 1,
            'text'  => '站内链接'
        ],
        [
            'key'   => 'outside',
            'value' => 2,
            'text'  => '站外链接'
        ]
    ];


    /**
     * 排序最大值
     * @var int
     */
    protected static $maxSort = 999999;
    /**
     * 排序最小值
     * @var int
     */
    protected static $minSort = -999999;


    /**
     * 规则验证
     * @return array
     */
    public function rules()
    {

        // [状态]列表
        $statusList = array_column(self::getStatusList(), 'value');
        // [是否展示]列表
        $isShowList = array_column(self::getIsShowList(), 'value');
        // [链接类型]列表
        $urlTypeList = array_column(self::getUrlTypeList(), 'value');

        $parent = parent::rules();
        return ArrayHelper::merge($parent, [
            ['status', 'in', 'range' => $statusList, 'message' => '状态不合法'],
            ['is_show', 'in', 'range' => $isShowList, 'message' => '是否展示不合法'],
            ['url_type', 'in', 'range' => $urlTypeList, 'message' => '链接类型不合法'],
            ['sort', 'integer', 'max'     => self::getMaxSort(), 'min' => self::getMinSort()],
            ['parent_id', 'checkParentId'],
            [['pc_cate_temp', 'pc_list_temp', 'pc_detail_temp'], 'checkTemp'],
            [['mob_cate_temp', 'mob_list_temp', 'mob_detail_temp'], 'checkTemp'],
        ]);
    }

    /**
     * 重写label的 文字
     */
    public function attributeLabels()
    {

        $parent = parent::attributeLabels();
        return array_merge($parent, [
            'id'              => '编号',
            'name'            => '名称',
            'parent_id'       => '上级编号',
            'status'          => '状态',
            'is_show'         => '是否展示',
            'sort'            => '排序',
            'description'     => '详情',
            'level'           => '级别',
            'setting'         => '分类设置',
            'news_setting'    => '文章设置',
            'url_type'        => '链接类型',
            'url'             => '链接',
            'image'           => '图片',
            'pc_cate_temp'    => '【电脑端】分类页模板',
            'pc_list_temp'    => '【电脑端】列表页模板',
            'pc_detail_temp'  => '【电脑端】详情页模板',
            'mob_cate_temp'   => '【手机端】分类页模板',
            'mob_list_temp'   => '【手机端】列表页模板',
            'mob_detail_temp' => '【手机端】详情页模板',
            'extra_data'      => '附加数据',
            'extra_article'   => '文章附加数据',
            'add_time'        => '添加时间',
            'update_time'     => '更新时间',
        ]);
    }

    /**
     * 场景
     * @return array
     */
    public function scenarios()
    {

        $scenarios = parent::scenarios();
        return ArrayHelper::merge($scenarios, [
            // 自定义场景 (无用请删除)
            'scUpdate' => [
                'someAttributes'
            ]
        ]);
    }

    /**
     * 检测 模板信息
     * @param null $attributeNames
     * @param bool $clearErrors
     * @return bool
     */
    public function checkTemp($attributeNames = null, $clearErrors = true)
    {

        // 站外无需验证是否必须
        if ($this->getAttribute('url_type') == self::getUrlTypeOutside()) return true;

        // 站内检测模板
        $temp = $this->getAttribute($attributeNames);
        if (!isset($temp)) {
            $this->addError($attributeNames, '站内连接必须设置模板');
            return false;
        }


        // 模板是否不存在
        if (!file_exists(UtilsService::getFrontTempFolder() . $temp)) {
            $this->addError($attributeNames, '模板文件不存在');
            return false;
        }

        return true;
    }

    /**
     * 检测父级编号
     * @param null $attributeNames
     * @param bool $clearErrors
     * @return bool
     */
    public function checkParentId($attributeNames = null, $clearErrors = true)
    {

        // 父级菜单可过
        if ($this->getAttribute($attributeNames) == 0) {
            $this->setAttribute('level', 1); // 默认等级为1级
            return true;
        }

        // 查询信息
        $parentInfo = self::findOne([
            'id' => $this->getAttribute($attributeNames)
        ]);

        // 菜单不存在
        if (!$parentInfo) {
            $this->addError($attributeNames, '父级信息不存在，请选择其他分类');
            return false;
        }

        // 赋值默认当前级别
        $this->setAttribute('level', intval($parentInfo['level']) + 1);

        // 菜单已禁用
        if ($parentInfo['status'] != self::getStatusOpen()) {
            $this->addError($attributeNames, '父级信息暂不存在，请选择其他分类');
            return false;
        }

        return true;
    }

    /**
     * 自定义过滤单条[where]
     *  ` 仅限于通过方法[loadWhere]传入的条件, 可以在其中自定义逻辑
     *  ` 保证最终返回值为一维数组[Yii2]通用条件格式[运算符, 字段名, 值]
     * @param $condition array [sql]查询条件, 严格遵循Yii多条件查询:[运算符, 字段名, 值]
     * @return array
     */
    public function whereCustomFilter($condition = [])
    {

        // // 例：字段为编号 —— 操作符使用[IN]
        // if ($field == 'id') {
        //     return ['IN', $condition[1], $value[2]];
        // }

        // 最终返回必须为数组：[运算符, 字段名, 值]，符合Yii2规范
        return $condition;
    }

    /**
     * 获取分页信息
     * @param integer $page 当前页
     * @param integer $limit 获取几条
     * @param null $field 获取字段
     * @param array $opt 配置
     *  - removeIds - int|array 排除某些编号
     *  - loadHasChild - bool 加载是否有子集
     *  - loadChild - bool 加载子集
     *  - parentId - array 加载某条目列表
     *  - loadLevelName - bool 加载分级标题, 如：五金/铁桶/铝合金桶
     *  - childNoDel - bool 子集没有是否删除子集键
     * @return PageListEntity
     */
    public function getPaginate($page, $limit, $field = null, $opt = [])
    {

        // 当前页面计算
        $page = max($page - 1, 0);

        // 查找的 字段空的 就默认给列表
        if (!$field) $field = '*';

        // 基础 where加载完毕
        $this->getBaseSql()->select($field);

        // 需要排除编号的
        if (!isset($opt['removeIds'])) $opt['removeIds'] = [];

        // 需要查询父级编号的
        if (!empty($opt['loadChild']) && $opt['loadChild'] && isset($opt['parentId'])) {
            $this->getBaseSql()->where(
                UtilsService::whereRm($this->where, 'parent_id')
            )->andWhere([
                'AND',
                ['NOT IN', 'id', $opt['removeIds']],
                ['=', 'parent_id', $opt['parentId']]
            ]);
        }

        // 数据的获取 分页等
        $list = $this->getBaseSql()->offset($page * $limit)
            ->limit($limit)
            ->asArray()->all();

        // 格式化数据后的列表
        $list = $this->formatData($list, $field, $opt);
        // 总数量
        $total = $this->getBaseSql()->count();

        return PageListEntity::loadModel(compact('list', 'total'));
    }

    /**
     * 格式化列表活详情数据
     * @param array $list 列表
     * @param array|string $field 字段列表
     * @param array $opt 设置
     * @return mixed
     */
    public function formatData($list, $field, $opt = [])
    {

        // 为空直接返回
        if (empty($list)) return $list;
        // 需要返回第一组（可能不是二维数组）
        $needFirst = false;
        if (!is_array(array_values($list)[0])) {
            $needFirst = true;
            $list      = [$list];
        }

        ### 某些参数初始化
        // 加载是否还有子集
        $opt['loadHasChild'] = !(empty($opt['loadHasChild']) || !$opt['loadHasChild']);
        // 子集列表没有直接删除键
        $opt['childNoDel'] = !(!isset($opt['childNoDel']) || !$opt['childNoDel']);


        // 格式化数据
        foreach ($list as $k => &$v) {

            // 更新时间
            if (isset($v['add_time'])) {
                $v['add_time_text']   = date('Y-m-d H:i:s', $v['add_time']);
                $v['add_time_text_s'] = date('Y-m-d', $v['add_time']);
            }

            // 更新时间
            if (isset($v['update_time'])) {
                $v['update_time_text']   = date('Y-m-d H:i:s', $v['update_time']);
                $v['update_time_text_s'] = date('Y-m-d', $v['update_time']);
            }

            // 状态 文本
            if (isset($v['status'])) {
                $v['status_text'] = self::getStatusText($v['status']);
            }

            // 是否展示 文本
            if (isset($v['is_show'])) {
                $v['is_show_text'] = self::getIsShowText($v['is_show']);
            }

            // 开启SEO 文本
            if (isset($v['open_seo'])) {
                $v['open_seo_text'] = self::getOpenSeoText($v['open_seo']);
            }

            // 链接类型 文本
            if (isset($v['url_type'])) {
                $v['url_type_text'] = self::getUrlTypeText($v['url_type']);
            }

            // [说明]HTML
            if (isset($v['description'])) {
                $v['description'] = htmlspecialchars_decode($v['description']);
                $v['description'] = FileService::addHtmlImgDomain($v['description']);
            }

            // [附加数据] 数组化
            if (isset($v['extra_data'])) {
                $v['extra_data'] = json_decode($v['extra_data'], true);
            }

            // [文章附加数据] 数组化
            if (isset($v['extra_article'])) {
                $v['extra_article'] = json_decode($v['extra_article'], true);
            }

            // 需要加载是否有子集
            if ($opt['loadHasChild'] && (empty($v['level']) || $v['level'] < 3)) {

                // 没有子集了 返回
                $childCount        = self::find()->where([
                    'parent_id' => $v['id'],
                    'status'    => $v['status'],
                    'is_show'   => !isset($v['is_show']) ? [
                        self::getIsShowShow(),
                        self::getIsShowHide()
                    ] : $v['is_show']
                ])->andWhere([
                    'AND',
                    ['NOT IN', 'id', $opt['removeIds']]
                ])->count();
                $v['had_children'] = false;
                if ($childCount >= 1) $v['had_children'] = true;
            } else if (!empty($opt['loadHasChild']) && $opt['loadHasChild']) {
                $v['had_children'] = false;
            }

            // 需要加载子集
            if (!empty($opt['loadChild']) && (
                    $opt['loadChild'] === true || in_array($v['id'], $opt['loadChild'])
                ) && !empty($v['level']) && intval($v['level']) <= 2
            ) {

                $v['children'] = $this->getPaginate(1, 200, $field, array_merge($opt, [
                    'parentId' => $v['id']
                ]))->getList();
                // 子集编号列表
                $v['child_id_list'] = array_column($v['children'], 'id');
                // 一级列表 - 涉及2个级别列表
                if (!empty($v['level']) && intval($v['level']) == 1) {
                    $v['lv_3_id_list'] = UtilsService::arrayListMerge(array_column(
                        $v['children'], 'child_id_list'));
                }
                if ($opt['childNoDel'] && empty($v['children'])) unset($v['children']);
            }

            // 需要加载等级列表
            if (!empty($v['parent_id']) && !empty($opt['loadLevelName']) && $opt['loadLevelName']) {
                $stageModel = self::loadModel($v['parent_id']);
                // 空的话略过了
                if (empty($stageModel)) {
                    $v['level_name'] = [];
                    continue;
                }
                // 获取列表
                $v['level_name'] = $stageModel->getLevelNameList(true, true,
                        ' - ', 2) . ' - ' . $v['name'];
            }

        }

        reset($list);
        return $needFirst ? current($list) : $list;
    }

    /**
     * 添加|保存
     * @param bool $runValidation 是否仅仅运行验证，不运行保存
     * @param string[]|null|string $attributeNames 仅仅保存某几个字段
     * @return bool
     */
    public function save($runValidation = false, $attributeNames = null)
    {

        ### 单个操作[缓存保存前一些格式化]
        $nowTime = time();
        // 添加时间
        if (empty($this->add_time)) $this->add_time = $nowTime;
        // 更新时间
        $this->update_time = $nowTime;
        // 图片 - 做三方适配
        $this->setAttribute('image', FileService::delImgDomain(
            $this->getAttribute('image')
        ));
        // 详情 - 图片做三方适配
        $this->setAttribute('description', FileService::delHtmlImgDomain(
            $this->getAttribute('description')
        ));
        // 详情 - 实体化
        $this->setAttribute('description', htmlspecialchars(
            $this->getAttribute('description')
        ));

        ### 批量操作[缓存保存前一些格式化]
        foreach ($this->getAttributes() as $k => $v) {
            // 字段类型为[JSON]类型需要转为数组 - 保存自动转为[JSON]
            if (is_string($v) && ConvertService::isJson($v)) {
                $this->setAttribute($k, json_decode($v, true));
                continue;
            }
        }

        // 检测
        if ($this->hasErrors() || !$this->validate($attributeNames)) {

            // 记录下错误日志
            \Yii::error([
                "`````````````````````````````````````````````````````````",
                "``                      数据库错误                       ``",
                "`` 错误详情: [[文章分类]数据库操作模型]验证数据失败             ``",
                "`` 错误信息和参数详情:                                     ``",
                "`````````````````````````````````````````````````````````",
                $this->getAttributes(),
                $this->getErrors()
            ], 'db');
            return false;
        }

        // 需要 && 执行保存
        if (!$runValidation && !parent::save(false, $attributeNames)) {

            // 记录下错误日志
            \Yii::error([
                "`````````````````````````````````````````````````````````",
                "``                      数据库错误                       ``",
                "`` 错误详情: [[文章分类]数据库操作模型]保存数据失败             ``",
                "`` 错误信息和参数详情:                                     ``",
                "`````````````````````````````````````````````````````````",
                $this->getAttributes(),
                $this->getErrors()
            ], 'db');
            return false;
        }

        return true;
    }

    /**
     * 以此记录开始往上 获取级联列表文本
     * @param bool $first 是否第一次
     * @param bool $returnString 是否返回标题字符
     * @param string $break 返回标题字符分隔符
     * @param int $maxLevel 最大等级
     * @return array|mixed|string
     */
    public function getLevelNameList($first = true, $returnString = true, $break = '-',
                                     $maxLevel = 100)
    {

        // 规定级别直接返回空
        if ($this->getAttribute('level') < $maxLevel) return $returnString ? '' : [];

        $parentId = $this->getAttribute('parent_id');
        // 第一次 没有父级信息就返回下
        if (empty($parentId) && $first) {

            return $returnString ?
                $this->getAttribute('name') :
                [
                    [
                        'name'  => $this->getAttribute('name'),
                        'level' => $this->getAttribute('level')
                    ]
                ];
        }

        // 非第一次循环 没有父级信息就返回下
        if (empty($parentId) && !$first) {

            return [
                [
                    'name'  => $this->getAttribute('name'),
                    'level' => $this->getAttribute('level')
                ]
            ];
        }

        // 再去查询父级走此方法
        $model = self::loadModel([
            'id'     => $this->getAttribute('parent_id'),
            'status' => self::getStatusOpen()
        ]);
        if (!$model) {

            return [
                [
                    'name'  => $this->getAttribute('name'),
                    'level' => $this->getAttribute('level')
                ]
            ];
        }
        // 其父级信息
        $parent = $model->getLevelNameList(false);
        // 保证为数组
        $parent = empty($parent) ? [] : $parent;

        // 非第一次加载数据塑造
        if (!$first) {
            return array_merge([
                [
                    'name'  => $this->getAttribute('name'),
                    'level' => $this->getAttribute('level')
                ]
            ], $parent);
        }

        // 第一次加载返回最终数据
        $parent = array_column(array_merge([
            [
                'name'  => $this->getAttribute('name'),
                'level' => $this->getAttribute('level')
            ]
        ], $parent), null, 'level');
        ksort($parent);
        // 无需返回字符串
        if (!$returnString) return array_column($parent, 'name');
        // 需要返回字符串
        return implode($break, array_column($parent, 'name'));
    }


    /**
     * [静态方法]批量快速更新某些字段
     * @param $condition
     * @param array $fieldVal
     * @return bool
     */
    public static function updateField($condition, $fieldVal = [])
    {

        // 验证字段
        $model = self::loadModel();
        $model->load($fieldVal, '');
        if (!$model->validate(array_keys($fieldVal))) {
            $error = UtilsService::getModelError($model->getErrors());
            self::$error_[$error['column']] = [$error['msg']];
            return false;
        }
        // 重新取值规则化后的特定值列表
        $fieldVal = $model->getAttributes(array_keys($fieldVal));

        $db = \Yii::$app->db->createCommand();

        try {

            $db->update(self::tableName(), $fieldVal, $condition)->execute();

            // 否则成功
            return true;
        } catch (\Exception $error) {

            // 记录下错误日志
            \Yii::error([

                "`````````````````````````````````````````````````````````",
                "``                      数据库错误                       ``",
                "`` 错误详情: [[文章分类]数据库操作模型]批量修改[指定字段]失败，   ``",
                "``         {$error->getMessage()}                       ``",
                "`` SQL语句: {$db->getRawSql()}                         ``",
                "`` 错误信息和参数详情:                                     ``",
                "`````````````````````````````````````````````````````````",
                $error->getTraceAsString()
            ], 'db');

            // 静态错误
            self::$error_['db_error'] = empty(self::$error_['db_error']) ?
                [$error->getMessage()] : array_merge(self::$error_['db_error'], [$error->getMessage()]);

            return false;
        }
    }

    /**
     * 批量添加数据
     * @param array $createData
     * @return bool
     */
    public static function createData($createData = [])
    {

        $db = \Yii::$app->db->createCommand();
        try {

            ### 先数据格式化
            // 如果是一维数组则二维数组化
            if (ArrayHelper::isAssociative($createData)) {
                $createData = [$createData];
            }
            $values = [];
            foreach ($createData as $k => $v) {

                $model = self::loadModel();
                $model->load($createData[$k], '');
                if (!$model->save(true)) {
                    // 取出错误信息
                    $error = UtilsService::getModelError($model->errors);
                    // 添加到静态方法上
                    self::$error_[$error['column']] = [$error['msg']];
                    return false;
                }

                $createData[$k] = $model->getAttributes($model::getTableSchema()->getColumnNames());

                // 循环一些数据
                foreach ($createData[$k] as $kc => $vc) {
                    // 字段类型为[JSON]类型需要转为[JSON]
                    if (is_array($vc)) {
                        $createData[$k][$kc] = json_encode($vc, JSON_UNESCAPED_UNICODE);
                        continue;
                    }
                }

                // 值赋值
                $values[] = array_values($createData[$k]);;
            }

            ### 取出此次操作的字段列表
            $columns = !current($createData) ? [] : array_keys(current($createData));

            // 执行
            $addResult = $db->batchInsert(self::tableName(), $columns, $values)->execute();

            return $addResult;
        } catch (\Exception $error) {

            // 记录下错误日志
            \Yii::error([

                "`````````````````````````````````````````````````````````",
                "``                      数据库错误                       ``",
                "`` 错误详情: [[文章分类]数据库操作模型]批量添加[数据]失败，      ``",
                "``         {$error->getMessage()}                       ``",
                "`` SQL语句: {$db->getRawSql()}                         ``",
                "`` 错误信息和参数详情:                                     ``",
                "`````````````````````````````````````````````````````````",
                $error->getTraceAsString()
            ], 'db');

            // 静态错误
            self::$error_['db_error'] = empty(self::$error_['db_error']) ?
                [$error->getMessage()] : array_merge(self::$error_['db_error'], [$error->getMessage()]);

            return false;
        }
    }

    /**
     * 更新某些字段自增|自减
     * @param $condition
     * @param array $fieldVal 增/减加的字段
     * @return bool
     */
    public static function updateCounter($condition, $fieldVal = [])
    {

        $model = new self();
        foreach ($fieldVal as $k => $v) {

            if (!$model->hasAttribute($k)) {

                unset($fieldVal[$k]);
                continue;
            }
        }

        try {

            $model->updateAllCounters($fieldVal, $condition);

            // 否则成功
            return true;
        } catch (\Exception $error) {

            // 记录下错误日志
            \Yii::error([

                "`````````````````````````````````````````````````````````",
                "``                      数据库错误                       ``",
                "`` 错误详情: [[文章分类]数据库操作模型]批量增/减[指定字段]失败   ``",
                "``         {$error->getMessage()}                       ``",
                "`` 错误信息和参数详情:                                     ``",
                "`````````````````````````````````````````````````````````",
                $error->getTraceAsString()
            ], 'db');

            // 静态错误
            self::$error_['db_error'] = empty(self::$error_['db_error']) ?
                [$error->getMessage()] : array_merge(self::$error_['db_error'], [$error->getMessage()]);

            return false;
        }
    }

    /**
     * 格式化[附加数据]
     * @param $data
     * @return array
     */
    public static function formatExtraData($data)
    {
        $data    = is_array($data) ? $data : explode(',', $data);
        $endData = [];
        foreach ($data as $k => $v) {
            if (empty($v) || !isset($v['name'])) continue;
            $endData[$v['name']] = $v['value'];
        }
        return $endData;
    }


    /**
     * 返回排序最大值
     * @return int
     */
    public static function getMaxSort()
    {
        return self::$maxSort;
    }

    /**
     * 返回排序最小值
     * @return int
     */
    public static function getMinSort()
    {
        return self::$minSort;
    }


    /**
     * 获取[状态][关闭]值
     * @return mixed
     */
    public static function getStatusDisabled()
    {

        $list = array_column(self::$statusList, null, 'key');
        return $list['disabled']['value'];
    }

    /**
     * 获取[状态][开启]值
     * @return mixed
     */
    public static function getStatusOpen()
    {

        $list = array_column(self::$statusList, null, 'key');
        return $list['open']['value'];
    }

    /**
     * 获取[状态]文本
     * @param $value
     * @return mixed|string
     */
    public static function getStatusText($value)
    {

        // 列表
        $list = array_column(self::$statusList, null, 'value');
        // 不合法 - 不存在
        if (empty($list[$value]['text']))

            return '--';

        // 最终正常返回
        return $list[$value]['text'];
    }

    /**
     * 获取[状态]列表 值
     * @return mixed|string
     */
    public static function getStatusList()
    {

        // 最终正常返回
        return self::$statusList;
    }


    /**
     * 获取[是否展示][是]值
     * @return mixed
     */
    public static function getIsShowShow()
    {

        $list = array_column(self::$isShowList, null, 'key');
        return $list['show']['value'];
    }

    /**
     * 获取[是否展示][否]值
     * @return mixed
     */
    public static function getIsShowHide()
    {

        $list = array_column(self::$isShowList, null, 'key');
        return $list['hide']['value'];
    }

    /**
     * 获取[是否展示]文本
     * @param $value
     * @return mixed|string
     */
    public static function getIsShowText($value)
    {

        // 列表
        $list = array_column(self::$isShowList, null, 'value');
        // 不合法 - 不存在
        if (empty($list[$value]['text']))

            return '--';

        // 最终正常返回
        return $list[$value]['text'];
    }

    /**
     * 获取[是否展示]列表 值
     * @return mixed|string
     */
    public static function getIsShowList()
    {

        // 最终正常返回
        return self::$isShowList;
    }


    /**
     * 获取[开启SEO]关闭 值
     * @return mixed
     */
    public static function getOpenSeoClose()
    {

        $list = array_column(self::$openSeoList, null, 'key');
        return $list['close']['value'];
    }

    /**
     * 获取[开启SEO]开启 值
     * @return mixed
     */
    public static function getOpenSeoOpen()
    {

        $list = array_column(self::$openSeoList, null, 'key');
        return $list['open']['value'];
    }

    /**
     * 获取[开启SEO]文本
     * @param $value
     * @return mixed|string
     */
    public static function getOpenSeoText($value)
    {

        // 列表
        $list = array_column(self::$isShowList, null, 'value');
        // 不合法 - 不存在
        if (empty($list[$value]['text'])) return '--';

        // 最终正常返回
        return $list[$value]['text'];
    }

    /**
     * 获取[开启SEO]列表 值
     * @return mixed|string
     */
    public static function getOpenSeoList()
    {

        // 最终正常返回
        return self::$openSeoList;
    }


    /**
     * 获取[链接类型]站点内 值
     * @return mixed
     */
    public static function getUrlTypeSite()
    {

        $list = array_column(self::$urlTypeList, null, 'key');
        return $list['site']['value'];
    }

    /**
     * 获取[链接类型]站点内 值
     * @return mixed
     */
    public static function getUrlTypeOutside()
    {

        $list = array_column(self::$urlTypeList, null, 'key');
        return $list['outside']['value'];
    }

    /**
     * 获取[链接类型]文本
     * @param $value
     * @return mixed|string
     */
    public static function getUrlTypeText($value)
    {

        // 列表
        $list = array_column(self::$isShowList, null, 'value');
        // 不合法 - 不存在
        if (empty($list[$value]['text'])) return '--';

        // 最终正常返回
        return $list[$value]['text'];
    }

    /**
     * 获取[链接类型]列表 值
     * @return mixed|string
     */
    public static function getUrlTypeList()
    {

        // 最终正常返回
        return self::$urlTypeList;
    }


    /**
     * 获取静态错误
     * @return mixed
     */
    public static function getStaticErrors()
    {
        return self::$error_;
    }
}
